class_name Card
extends Resource

enum Type {ATTACK, SKILL, POWER}
enum Rarity {COMMON, RARE, LEGEND, MYTHIC}
enum Target {SELF, SINGLE_ENEMY, ALL_ENEMIES, EVERYONE}

const RARITY_COLORS := {
	Card.Rarity.COMMON: Color.GRAY,
	Card.Rarity.RARE: Color.CORNFLOWER_BLUE,
	Card.Rarity.LEGEND: Color.GOLD,
	Card.Rarity.MYTHIC: Color.PURPLE,
}

@export_group("Card Attributes")
@export var id: String
@export var type: Type
@export var rarity: Rarity
@export var target: Target
@export var cost: int
@export var card_max_repeat_num:int
@export var card_current_repeat_num:int 
@export var scheduled_effect:ScheduledEffect  # 单个调度效果（向后兼容）
@export var scheduled_effects: Array[ScheduledEffect]  # 多个调度效果
@export var custom_effect:Resource

#是否消耗
@export var exhausts: bool = false

@export_group("Card Visuals")
@export var icon: Texture
@export_multiline var tooltip_text: String
@export var sound: AudioStream

func is_single_targeted() -> bool:
	return target == Target.SINGLE_ENEMY
 

func _get_targets(targets: Array[Node]) -> Array[Node]:
	if not targets:
		return []
	
	var tree := targets[0].get_tree()
	
	match  target:
		Target.SELF:
			return tree.get_nodes_in_group("player")
		Target.ALL_ENEMIES:
			return tree.get_nodes_in_group("enemies")
		Target.EVERYONE:
			return tree.get_nodes_in_group("player") + tree.get_nodes_in_group("enemies")
		_:
			return []


func play(targets: Array[Node], char_stats: CharacterStats, modifiers: ModifierHandler) -> void:
	# 记录卡牌初始使用次数
	print("Card.play: 卡牌 %s 开始播放，当前使用次数: %d" % [id, card_current_repeat_num])
	
	# 只有当卡牌有使用次数限制且当前次数不为0时，才减少使用次数
	if card_max_repeat_num > 0 and card_current_repeat_num > 0:
		card_current_repeat_num -= 1
		print("Card.play: 卡牌 %s 使用次数减少，剩余: %d" % [id, card_current_repeat_num])
	
	# 触发卡牌播放事件
	Events.card_played.emit(self)
	
	# 使用能量消耗方法（支持贷款能量系统）
	var effective_cost = get_effective_cost_from_targets(targets)
	char_stats.spend_mana(effective_cost, false)  # 普通卡牌不允许贷款
	
	if is_single_targeted():
		apply_effects(targets, modifiers)
	else:
		apply_effects(_get_targets(targets), modifiers)


func apply_effects(_targets: Array[Node], _modifiers: ModifierHandler) -> void:
	print("🔍 Card.apply_effects: 卡牌 %s 的apply_effects被调用" % id)
	print("🔍 Card.apply_effects: 目标数量: %d" % _targets.size())
	
	# 如果有自定义效果，优先执行
	if custom_effect and custom_effect.has_method("execute"):
		print("🔍 Card.apply_effects: 执行自定义效果: %s" % custom_effect.get_class())
		custom_effect.execute(_targets)
	else:
		print("🔍 Card.apply_effects: 没有自定义效果")
	
	# 处理调度效果
	print("🔍 Card.apply_effects: 开始处理调度效果")
	_apply_scheduled_effects(_targets)


func _apply_scheduled_effects(_targets: Array[Node]) -> void:
	var battle = _targets[0].get_tree().get_first_node_in_group("battle") if _targets.size() > 0 else null
	if not battle or not battle.resource_scheduler:
		print("❌ 无法找到资源调度器")
		return
	
	print("🔍 开始处理调度效果...")
	print("  - scheduled_effects 数量: %d" % (scheduled_effects.size() if scheduled_effects else 0))
	print("  - scheduled_effect 是否存在: %s" % ("是" if scheduled_effect else "否"))
	
	# 处理多个调度效果（优先）
	if scheduled_effects and scheduled_effects.size() > 0:
		print("📋 处理多个调度效果...")
		for i in range(scheduled_effects.size()):
			var effect = scheduled_effects[i]
			print("  - 效果 %d: %s" % [i, effect.id if effect else "null"])
			if effect:
				# 复制效果以避免修改原始资源
				var effect_copy = effect.duplicate()
				# 动态调整触发回合（如果需要）
				_adjust_scheduled_effect_timing(effect_copy, battle)
				battle.resource_scheduler.add_scheduled_effect(effect_copy)
				print("📋 已添加调度效果: %s" % effect_copy.id)
	# 处理单个调度效果（向后兼容）
	elif scheduled_effect:
		print("📋 处理单个调度效果...")
		var effect_copy = scheduled_effect.duplicate()
		_adjust_scheduled_effect_timing(effect_copy, battle)
		battle.resource_scheduler.add_scheduled_effect(effect_copy)
		print("📋 已添加调度效果: %s" % effect_copy.id)
	else:
		print("⚠️ 没有找到任何调度效果")


func _adjust_scheduled_effect_timing(effect: ScheduledEffect, battle: Node) -> void:
	# 根据当前游戏状态动态调整触发时机
	var current_turn = battle.current_turn
	var current_phase = battle.current_phase
	
	print("🔧 调整效果 %s 时机: 当前回合 %d, 当前阶段 %d, 原触发回合 %d" % [effect.id, current_turn, current_phase, effect.trigger_turn])
	
	# 如果效果设置为当前回合但当前是敌人回合，则延迟到下回合
	if effect.trigger_turn == 0 and current_phase >= TurnPhaseConstants.ENEMY_START:
		effect.trigger_turn = current_turn + 1
		print("🔧 调整效果 %s 触发回合: 0 -> %d (当前为敌人回合)" % [effect.id, effect.trigger_turn])
	# 如果效果设置为下回合，则设置为当前回合+1
	elif effect.trigger_turn == 1:
		effect.trigger_turn = current_turn + 1
		print("🔧 调整效果 %s 触发回合: 1 -> %d (下回合效果)" % [effect.id, effect.trigger_turn])
	# 如果效果设置为当前回合，则设置为当前回合
	elif effect.trigger_turn == 0:
		effect.trigger_turn = current_turn
		print("🔧 调整效果 %s 触发回合: 0 -> %d (当前回合效果)" % [effect.id, effect.trigger_turn])


func get_default_tooltip() -> String:
	return tooltip_text


func get_updated_tooltip(_player_modifiers: ModifierHandler, _enemy_modifiers: ModifierHandler) -> String:
	return tooltip_text

# 新增：获取实际cost的方法
func get_effective_cost(char_stats: CharacterStats) -> int:
	var effective_cost = cost
	
	# 注意：char_stats是CharacterStats类型，没有modifier_handler
	# cost增加功能需要在play方法中通过targets参数实现
	# 这里暂时返回基础cost
	
	return effective_cost

# 新增：通过targets获取实际cost的方法
func get_effective_cost_from_targets(targets: Array[Node]) -> int:
	var effective_cost = cost
	print("🔍 卡牌 %s 基础cost: %d" % [id, cost])
	
	# 通过targets获取玩家的modifier_handler
	if targets.size() > 0:
		var player = _get_player_from_targets(targets)
		if player and player.get("modifier_handler") != null:
			print("🔍 找到玩家: %s" % player.name)
			var cost_modifier = player.modifier_handler.get_modifier(Modifier.Type.CARD_COST)
			if cost_modifier:
				print("🔍 找到CARD_COST修改器，子节点数量: %d" % cost_modifier.get_child_count())
				# 使用get_modified_value(0)来获取cost增加值，因为0 + 增加值 = 增加值
				var cost_increase = cost_modifier.get_modified_value(0)
				effective_cost += cost_increase
				print("💰 卡牌 %s cost增加: %d → %d (增加量: %d)" % [id, cost, effective_cost, cost_increase])
			else:
				print("🔍 未找到CARD_COST修改器")
		else:
			print("🔍 未找到玩家或modifier_handler")
	else:
		print("🔍 targets为空")
	
	print("🔍 卡牌 %s 最终effective_cost: %d" % [id, effective_cost])
	return effective_cost

# 新增：检查是否可以播放（考虑cost增加）
func can_play_from_targets(targets: Array[Node], char_stats: CharacterStats) -> bool:
	var effective_cost = get_effective_cost_from_targets(targets)
	return char_stats.current_mana >= effective_cost

# 辅助方法：从targets中获取玩家
func _get_player_from_targets(targets: Array[Node]) -> Node:
	for target in targets:
		if target is Player:
			return target
		# 如果target不是Player，尝试通过场景树查找
		var tree = target.get_tree()
		if tree:
			var player = tree.get_first_node_in_group("player")
			if player:
				return player
	return null

# 静态方法：查找player_handler的通用方法
static func find_player_handler(tree: SceneTree) -> Node:
	if not tree:
		return null
	
	# 方法1：通过组查找
	var player_handler = tree.get_first_node_in_group("player_handler")
	if player_handler:
		return player_handler
	
	# 方法2：通过battle节点查找
	var battle = tree.get_first_node_in_group("battle")
	if battle:
		player_handler = battle.get_node_or_null("PlayerHandler")
		if player_handler:
			return player_handler
	
	# 方法3：通过player的父节点查找
	var player = tree.get_first_node_in_group("player")
	if player and player.get_parent():
		player_handler = player.get_parent().get_node_or_null("PlayerHandler")
		if player_handler:
			return player_handler
	
	return null

# 静态方法：查找player的通用方法
static func find_player(tree: SceneTree) -> Node:
	if not tree:
		return null
	
	return tree.get_first_node_in_group("player")

# 静态方法：查找battle的通用方法
static func find_battle(tree: SceneTree) -> Node:
	if not tree:
		return null
	
	return tree.get_first_node_in_group("battle")
